// #include "Log.hpp"
// #include <memory>

// #include <iostream>

// // //循环引用解决办法1
// // class Base{
// // public:
// //     virtual void test() = 0;
// // };

// // class A {
// // public:
// //     void set(Base* ptr){
// //         b = ptr;
// //     }
// //     void test(){
// //         b->test(); //
// //     }

// //     Base* b;
// // };

// // class B : public Base{
// // public:
// //     B(){
// //         a = new A();
// //     }
// //     void test(){
// //         std::cout << "hello" << std::endl;
// //     }
// //     A* a;
// // };

// // int main()
// // {
// //     A a;
// //     B b;

// //     a.set(&b);

// //     a.test();
// //     return 0;
// // }

// int main()
// {
//     // //策略模式 -- 用基类的智能指针实现多态效果
//     // //std::unique_ptr<wzx::log_strategy> up1(new wzx::console_log_strategy);
//     // //up1->refresh("xxxxx");

//     // std::unique_ptr<wzx::log_strategy> up2(new wzx::file_log_strategy);
//     // up2->refresh("xxxx");

//     LOG(wzx::log_level::DEBUG) << 1.1 << "kkk" << 10;
//     SWITCH_FILE;
//     LOG(wzx::log_level::DEBUG) << 1.2 << "kkk" << 10;
//     LOG(wzx::log_level::DEBUG) << 1.3 << "kkk" << 10;
//     LOG(wzx::log_level::DEBUG) << 1.4 << "kkk" << 10;

//     return 0;

// }






// // atomic::compare_exchange_weak example:
// #include <iostream> // std::cout
// #include <atomic>   // std::atomic
// #include <thread>   // std::thread
// #include <vector>   // std::vector
// using namespace std;

// // a simple global linked list:
// struct Node
// {
//     int value;
//     Node *next;
// };

// std::atomic<Node *> list_head(nullptr);

// void append(int val, int n)
// {
//     // std::this_thread::sleep_for(std::chrono::seconds(1));
//     for (int i = 0; i < n; i++)
//     {
//         // append an element to the list
//         Node *oldHead = list_head;
//         Node *newNode = new Node{val + i, oldHead};
//         // what follows is equivalent to: list_head = newNode, but in athread - safe way : 
//         while (!list_head.compare_exchange_weak(oldHead, newNode))
//             newNode->next = oldHead;
//     }
// }

// int main()
// {
//     // spawn 10 threads to fill the linked list:
//     std::vector<std::thread> threads;
//     threads.emplace_back(append, 0, 10);
//     threads.emplace_back(append, 20, 10);
//     threads.emplace_back(append, 30, 10);
//     threads.emplace_back(append, 40, 10);
//     for (auto &th : threads)
//         th.join();

//     // print contents:
//     for (Node *it = list_head; it != nullptr; it = it->next)
//         std::cout << ' ' << it->value;
//     std::cout << '\n';

//     // cleanup:
//     Node *it;
//     while (it = list_head)
//     {
//         list_head = it->next;
//         delete it;
//     }
//     return 0;
// }









//为什么需要家地址, 函数名和&函数名不是一样的
// 对于全局函数和类的成员函数是不一样的, 您微信回我一个精细一点的解释 谢谢老师!!!!





#include "thread_pool.hpp"
#include <functional>
#include <iostream>


void print()
{
    cout << "打印任务....." << endl;
}



typedef void (*task_p)(void);

int main()
{
    //SWITCH_FILE;
    
    thread_pool<task_p>::get_singleton()->start();

    thread_pool<task_p>::get_singleton()->task_push(print);
    thread_pool<task_p>::get_singleton()->task_push(print);
    thread_pool<task_p>::get_singleton()->task_push(print);
    thread_pool<task_p>::get_singleton()->task_push(print);
    thread_pool<task_p>::get_singleton()->task_push(print);

    // 有点卡,哈哈
    // 打个电话    我能听见你说话, 那你直接整吧
    thread_pool<task_p>::get_singleton()->stop();

    thread_pool<task_p>::get_singleton()->join_all();


    return 0;
}